exponential-backoff

What is exponential-backoff?

The exponential-backoff npm package is a utility that helps to perform an action repeatedly with a delay between each attempt that grows exponentially. It is commonly used to handle retries for operations that can fail due to transient errors, such as network requests or other temporary issues. The package provides a way to easily implement backoff strategies in a robust and flexible manner.

What are exponential-backoff's main functionalities?

Exponential backoff for asynchronous operations

This feature allows you to perform an asynchronous operation with an exponential backoff strategy. If the operation fails, it will be retried with increasing delays between each attempt.

const { backOff } = require('exponential-backoff');

backOff(() => {
  return new Promise((resolve, reject) => {
    // Your async operation here, e.g., a fetch request
    if (/* operation successful */) {
      resolve(result);
    } else {
      reject('Failed to complete operation');
    }
  });
});

Customizable backoff strategy

This feature allows you to customize the backoff strategy by setting options such as the number of attempts, the initial delay, and the multiplier for the delay between attempts.

const { backOff } = require('exponential-backoff');

const options = {
  delayFirstAttempt: true,
  numOfAttempts: 5,
  startingDelay: 100,
  timeMultiple: 2
};

backOff(() => {
  // Your async operation
}, options);

Handling of max delay

This feature allows you to specify a maximum delay between attempts, ensuring that the delay does not grow beyond a certain threshold.

const { backOff } = require('exponential-backoff');

const options = {
  maxDelay: 10000
};

backOff(() => {
  // Your async operation
}, options);

Other packages similar to exponential-backoff

retry

The 'retry' package provides similar functionality for implementing retry strategies. It supports both time-based and event-based retries. It is more low-level compared to 'exponential-backoff' and requires more setup but offers more flexibility.

async-retry

The 'async-retry' package is another alternative that offers a simple API for retrying asynchronous functions, with support for custom retries and exponential backoff. It is similar to 'exponential-backoff' but has a slightly different API design.

promise-retry

The 'promise-retry' package allows you to retry a promise-returning or async function, with an API that is very similar to 'async-retry'. It provides a flexible approach to handling retries with promises.

README

exponential-backoff

A utility that allows retrying a function with an exponential delay between attempts.

Installation

npm i exponential-backoff

Usage

The backOff<T> function takes a promise-returning function to retry, and an optional BackOffOptions object. It returns a Promise<T>.

function backOff<T>(
  request: () => Promise<T>,
  options?: BackOffOptions
): Promise<T>;

Here is an example retrying a function that calls a hypothetical weather endpoint:

import { backOff } from "exponential-backoff";

function getWeather() {
  return fetch("weather-endpoint");
}

async function main() {
  try {
    const response = await backOff(() => getWeather());
    // process response
  } catch (e) {
    // handle error
  }
}

main();

Migrating across major versions? Here are our breaking changes.

BackOffOptions

• delayFirstAttempt?: boolean

  Decides whether the startingDelay should be applied before the first call. If false, the first call will occur without a delay.

  Default value is false.

• jitter?: JitterType | string

  Decides whether a jitter should be applied to the delay. Possible values are full and none.

  Default value is none.

• maxDelay?: number

  The maximum delay, in milliseconds, between two consecutive attempts.

  Default value is Infinity.

• numOfAttempts?: number

  The maximum number of times to attempt the function.

  Default value is 10.

  Minimum value is 1.

• retry?: (e: any, attemptNumber: number) => boolean | Promise<boolean>

  The retry function can be used to run logic after every failed attempt (e.g. logging a message, assessing the last error, etc.). It is called with the last error and the upcoming attempt number. Returning true will retry the function as long as the numOfAttempts has not been exceeded. Returning false will end the execution.

  Default value is a function that always returns true.

• startingDelay?: number

  The delay, in milliseconds, before executing the function for the first time.

  Default value is 100 ms.

• timeMultiple?: number

  The startingDelay is multiplied by the timeMultiple to increase the delay between reattempts.

  Default value is 2.